package domain

import (
	"context"
	"net/http"

	"github.com/gin-gonic/gin"
	"github.com/mars/pkg/errors"
)

// Address 结构体对应用户地址信息
type Address struct {
	ID         string `json:"id" bson:"id"`                 // 地址ID
	Name       string `json:"name" bson:"name"`             // 收货人姓名
	Phone      string `json:"phone" bson:"phone"`           // 收货人电话
	Province   string `json:"province" bson:"province"`     // 省份
	City       string `json:"city" bson:"city"`             // 城市
	District   string `json:"district" bson:"district"`     // 区县
	Detail     string `json:"detail" bson:"detail"`         // 详细地址
	IsDefault  bool   `json:"isDefault" bson:"isDefault"`   // 是否默认地址
	CreateTime int64  `json:"createTime" bson:"createTime"` // 创建时间 (秒级时间戳)
	UpdateTime int64  `json:"updateTime" bson:"updateTime"` // 更新时间 (秒级时间戳)
}

// VipInfo 结构体对应 VIP 信息
type VipInfo struct {
	Type        string `json:"type" bson:"type"`                               // VIP类型: monthly|yearly|lifetime
	ActivatedAt int64  `json:"activatedAt" bson:"activatedAt"`                 // 激活时间 (秒级时间戳)
	ExpiresAt   *int64 `json:"expiresAt,omitempty" bson:"expiresAt,omitempty"` // 过期时间（终身会员为null） (秒级时间戳)
	OrderID     string `json:"orderId" bson:"orderId"`                         // 关联订单ID
	IsActive    bool   `json:"isActive" bson:"isActive"`                       // 是否激活
}

// User 结构体对应用户表
type User struct {
	ID            string    `json:"_id,omitempty" bson:"_id,omitempty"`         // 用户ID (通常由MongoDB自动生成)
	OpenID        string    `json:"openid" bson:"openid"`                       // 微信用户唯一标识
	NickName      string    `json:"nickName" bson:"nickName"`                   // 用户昵称
	AvatarUrl     string    `json:"avatarUrl" bson:"avatarUrl"`                 // 用户头像
	Phone         string    `json:"phone" bson:"phone"`                         // 手机号
	Gender        int       `json:"gender" bson:"gender"`                       // 性别：0未知，1男，2女
	Country       string    `json:"country" bson:"country"`                     // 国家
	Province      string    `json:"province" bson:"province"`                   // 省份
	City          string    `json:"city" bson:"city"`                           // 城市
	Addresses     []Address `json:"addresses" bson:"addresses"`                 // 地址列表
	Role          string    `json:"role" bson:"role"`                           // 用户角色: normal|vip
	Status        string    `json:"status" bson:"status"`                       // 用户状态: active|blocked|deleted
	VipInfo       *VipInfo  `json:"vipInfo,omitempty" bson:"vipInfo,omitempty"` // VIP信息（仅VIP用户），使用指针类型以支持不存在该字段的情况
	CreateTime    int64     `json:"createTime" bson:"createTime"`               // 注册时间 (秒级时间戳)
	UpdateTime    int64     `json:"updateTime" bson:"updateTime"`               // 更新时间 (秒级时间戳)
	LastLoginTime int64     `json:"lastLoginTime" bson:"lastLoginTime"`         // 最后登录时间 (秒级时间戳)
}

// UserQueryParams 用户查询参数
type UserQueryParams struct {
	Status  string `json:"status,omitempty"`  // 状态过滤
	Role    string `json:"role,omitempty"`    // 角色过滤
	VipType string `json:"vipType,omitempty"` // VIP类型过滤
	Keyword string `json:"keyword,omitempty"` // 关键字搜索
	PaginationParams
	SortParams
}

// NewDefaultUserQueryParams 创建默认用户查询参数
func NewDefaultUserQueryParams() UserQueryParams {
	return UserQueryParams{
		PaginationParams: DefaultPaginationParams,
		SortParams:       DefaultSortParams,
	}
}

// UserValidator 用户验证器
type UserValidator struct {
	paginationValidator *PaginationValidator
	idValidator         *IDValidator
	sortValidator       *SortValidator
	statusValidator     *EnumValidator
	roleValidator       *EnumValidator
	vipTypeValidator    *EnumValidator
	nicknameValidator   *StringValidator
	phoneValidator      *StringValidator
	avatarUrlValidator  *StringValidator
	locationValidator   *StringValidator
	keywordValidator    *StringValidator
}

// NewUserValidator 创建用户验证器
func NewUserValidator() *UserValidator {
	return &UserValidator{
		paginationValidator: NewPaginationValidator(1000),
		idValidator:         NewIDValidator("openid", 2, 128),
		sortValidator:       NewSortValidator([]string{"createTime", "updateTime", "lastLoginTime", "nickName"}),
		statusValidator: NewEnumValidator("user status",
			[]string{"active", "blocked", "deleted"}, false),
		roleValidator: NewEnumValidator("user role",
			[]string{"normal", "vip"}, false),
		vipTypeValidator: NewEnumValidator("vip type",
			[]string{"monthly", "yearly", "lifetime"}, false),
		nicknameValidator:  NewStringValidator("nickname", 64, false),
		phoneValidator:     NewStringValidator("phone", 20, false),
		avatarUrlValidator: NewStringValidator("avatar URL", 512, false),
		locationValidator:  NewStringValidator("location", 64, false),
		keywordValidator:   NewStringValidator("search keyword", 100, false),
	}
}

// ValidateQueryParams 验证查询参数
func (uv *UserValidator) ValidateQueryParams(cxt *gin.Context) (UserQueryParams, error) {
	// 验证分页参数
	pagination, err := uv.paginationValidator.ValidateAndParse(cxt)
	if err != nil {
		return UserQueryParams{}, err
	}

	// 验证排序参数
	sort, err := uv.sortValidator.ValidateAndParse(cxt)
	if err != nil {
		return UserQueryParams{}, err
	}

	// 验证用户状态
	status := cxt.Query("status")
	if err := uv.statusValidator.Validate(status); err != nil {
		return UserQueryParams{}, err
	}

	// 验证用户角色
	role := cxt.Query("role")
	if err := uv.roleValidator.Validate(role); err != nil {
		return UserQueryParams{}, err
	}

	// 验证VIP类型
	vipType := cxt.Query("vipType")
	if err := uv.vipTypeValidator.Validate(vipType); err != nil {
		return UserQueryParams{}, err
	}

	// 验证关键字
	keyword := cxt.Query("keyword")
	if err := uv.keywordValidator.Validate(keyword); err != nil {
		return UserQueryParams{}, err
	}

	return UserQueryParams{
		Status:           status,
		Role:             role,
		VipType:          vipType,
		Keyword:          keyword,
		PaginationParams: pagination,
		SortParams:       sort,
	}, nil
}

// ValidateOpenID 验证openid参数
func (uv *UserValidator) ValidateOpenID(cxt *gin.Context, paramName string) (string, error) {
	return uv.idValidator.ValidateFromParam(cxt, paramName)
}

// ValidateUserStatus 验证用户状态参数
func (uv *UserValidator) ValidateUserStatus(cxt *gin.Context, paramName string) (string, error) {
	status := cxt.Param(paramName)
	if status == "" {
		status = cxt.Query(paramName)
	}

	statusValidator := NewEnumValidator("user status",
		[]string{"active", "blocked", "deleted"}, true)
	if err := statusValidator.Validate(status); err != nil {
		return "", err
	}

	return status, nil
}

// ValidateUser 验证用户实体
func (uv *UserValidator) ValidateUser(user *User) error {
	if user == nil {
		return errors.New(http.StatusBadRequest, "user object is required")
	}

	// 验证openid
	if user.OpenID == "" {
		return errors.New(http.StatusBadRequest, "openid is required")
	}

	idValidator := NewIDValidator("openid", 2, 128)
	if len(user.OpenID) < idValidator.MinLength || len(user.OpenID) > idValidator.MaxLength {
		return errors.New(http.StatusBadRequest, "openid length must be between 2 and 128 characters")
	}

	// 验证昵称
	if user.NickName == "" {
		return errors.New(http.StatusBadRequest, "nickname is required")
	}

	if err := uv.nicknameValidator.Validate(user.NickName); err != nil {
		return err
	}

	// 验证性别
	if user.Gender < 0 || user.Gender > 2 {
		return errors.New(http.StatusBadRequest, "gender must be 0 (unknown), 1 (male), or 2 (female)")
	}

	// 验证其他字段
	if err := uv.avatarUrlValidator.Validate(user.AvatarUrl); err != nil {
		return err
	}

	if err := uv.phoneValidator.Validate(user.Phone); err != nil {
		return err
	}

	if err := uv.locationValidator.Validate(user.Country); err != nil {
		return err
	}

	if err := uv.locationValidator.Validate(user.Province); err != nil {
		return err
	}

	if err := uv.locationValidator.Validate(user.City); err != nil {
		return err
	}

	// 验证状态
	if user.Status != "" {
		if err := uv.statusValidator.Validate(user.Status); err != nil {
			return err
		}
	}

	// 验证角色
	if user.Role != "" {
		if err := uv.roleValidator.Validate(user.Role); err != nil {
			return err
		}
	}

	return nil
}

// ValidateUserForUpdate 验证用户更新请求
func (uv *UserValidator) ValidateUserForUpdate(user *User) error {
	if user == nil {
		return errors.New(http.StatusBadRequest, "user object is required")
	}

	// 对于更新操作，只验证非空字段
	if user.NickName != "" {
		if err := uv.nicknameValidator.Validate(user.NickName); err != nil {
			return err
		}
	}

	if user.Gender != 0 && (user.Gender < 0 || user.Gender > 2) {
		return errors.New(http.StatusBadRequest, "gender must be 0 (unknown), 1 (male), or 2 (female)")
	}

	if user.AvatarUrl != "" {
		if err := uv.avatarUrlValidator.Validate(user.AvatarUrl); err != nil {
			return err
		}
	}

	if user.Phone != "" {
		if err := uv.phoneValidator.Validate(user.Phone); err != nil {
			return err
		}
	}

	// 验证状态
	if user.Status != "" {
		if err := uv.statusValidator.Validate(user.Status); err != nil {
			return err
		}
	}

	// 验证角色
	if user.Role != "" {
		if err := uv.roleValidator.Validate(user.Role); err != nil {
			return err
		}
	}

	return nil
}

// ValidateVipInfo 验证VIP信息
func (uv *UserValidator) ValidateVipInfo(vipInfo *VipInfo) error {
	if vipInfo == nil {
		return errors.New(http.StatusBadRequest, "vip info is required")
	}

	if vipInfo.Type == "" {
		return errors.New(http.StatusBadRequest, "vip type is required")
	}

	if err := uv.vipTypeValidator.Validate(vipInfo.Type); err != nil {
		return err
	}

	if vipInfo.OrderID == "" {
		return errors.New(http.StatusBadRequest, "order ID is required")
	}

	orderIDValidator := NewStringValidator("order ID", 128, true)
	if err := orderIDValidator.Validate(vipInfo.OrderID); err != nil {
		return err
	}

	if vipInfo.ActivatedAt == 0 {
		return errors.New(http.StatusBadRequest, "activated time is required")
	}

	// 对于非终身会员，过期时间是必需的
	if vipInfo.Type != "lifetime" && (vipInfo.ExpiresAt == nil || *vipInfo.ExpiresAt == 0) {
		return errors.New(http.StatusBadRequest, "expires time is required for non-lifetime VIP")
	}

	return nil
}

// UserGateway 用户相关处理逻辑
type UserGateway interface {
	// Users 查询用户信息
	Users(ctx context.Context) ([]User, int64, error)

	// User 根据用户 openid 查询用户信息
	User(ctx context.Context, openid string) (*User, error)

	// CreateUser 创建新用户
	CreateUser(ctx context.Context, user *User) error

	// UpdateUser 更新用户信息
	UpdateUser(ctx context.Context, openid string, user *User) (int, error)

	// DeleteUser 删除用户（软删除，设置状态为deleted）
	DeleteUser(ctx context.Context, openid string) error

	// GetUsersByStatus 根据状态查询用户
	GetUsersByStatus(ctx context.Context, status string) ([]User, error)

	// GetVIPUsers 查询VIP用户
	GetVIPUsers(ctx context.Context) ([]User, error)

	// UpdateUserVIP 更新用户VIP信息
	UpdateUserVIP(ctx context.Context, openid string, vipInfo *VipInfo) (int, error)
}
